AE/AWB/AF Interface

#define isp_3A_ROW  (128)   /**< number of 3A statistic blocks in a row */
#define isp_3A_COL  (90)    /**< number of 3A statistic blocks in a column */ @brief Single AE HW statistics data*/
typedef struct
{
    U8  r;  /**< block pixel R average , 0~255*/
    U8  g;  /**< block pixel G average , 0~255, g=(Gr+Gb+1)>>1*/
    U8  b;  /**< block pixel B average , 0~255*/
    U8  y;  /**< block pixel Y average , 0~255, \
            y=(Ravg*9 +Gavg*19 +Bavg*4 + 16)>>5 */
}__attribute__((packed, aligned(1))) ISP_AE_SAMPLE;

/*! @brief Single AWB HW statistics data*/
typedef struct
{
    U8  r;  /**<center pixel R value , 0~255    */
    U8  g;  /**<center pixel G value , 0~255    */
    U8  b;  /**<center pixel B value , 0~255    */
}__attribute__((packed, aligned(1))) ISP_AWB_SAMPLE;

#define _3A_IR_HIST_BIN  (256)   /**< histogram type2 resolution*/

    typedef struct
    {
        u16 u2IRHist[_3A_IR_HIST_BIN];
    } ____attribute__((packed, aligned(1))) ISP_IR_HISTX;

typedef struct {
    MI_U32 u32StartX;   /*range : 0~1023*/
    MI_U32 u32StartY;   /*range : 0~1023*/
    MI_U32 u32EndX;     /*range : 0~1023*/
    MI_U32 u32EndY;     /*range : 0~1023*/
} AF_WINDOW_PARAM_t;

typedef struct {
    MI_U8 u8WindowIndex;
    AF_WINDOW_PARAM_t stParaAPI;
} CusAFWin_t;

//for Pretzel, Macaron, Pudding              //for Twinkie
typedef struct{                         typedef struct{
    MI_U8 high_iir[5*16];                       MI_U8 high_iir[6*16];
    MI_U8 low_iir[5*16];                        MI_U8 low_iir[6*16];
    MI_U8 luma[4*16];                           MI_U8 luma[6*16];
    MI_U8 sobel_v[5*16];                        MI_U8 sobel_v[6*16];
    MI_U8 sobel_h[5*16];                        MI_U8 sobel_h[6*16];
    MI_U8 ysat[3*16];                           MI_U8 ysat[3*16];
} AF_STATS_PARAM_t ;                        } AF_STATS_PARAM_t ;

typedef struct{                         typedef struct{
    AF_STATS_PARAM_t stParaAPI[16];             AF_STATS_PARAM_t stParaAPI;
} CusAFStats_t;                         } CusAFStats_t;

/*! @brief ISP ae algorithm result*/
typedef struct
{
    U32 Size;       /**< struct size*/
    U32 Change;    /**< if true, apply this result to hw register*/
    U32 Shutter;    /**< Shutter in us */
    U32 SensorGain; /**< Sensor gain, 1X = 1024 */
    U32 IspGain;    /**< ISP gain, 1X = 1024 */
    U32 ShutterHdrShort;    /**< Shutter in us */
    U32 SensorGainHdrShort; /**< Sensor gain, 1X = 1024 */
    U32 IspGainHdrShort;    /**< ISP gain, 1X = 1024 */
    U32 u4BVx16384; /**< Bv * 16384 in APEX system, EV = Av + Tv = Sv + Bv */
    U32 AvgY;       /**< frame brightness */
    U32 HdrRatio;   /**< hdr ratio, 1X = 1024 */

/*CUS3A v1.1*/
    U32 FNx10;           /**< F number * 10 */
    U32 DebandFPS;      /**< Target fps when running auto debanding*/
U32 WeightY;        /**< frame brightness with ROI weight*/

/*CUS3A v1.3*/
    U16 GMBlendRatio;  /**< Adaptive Gamma Blending Ratio from AE**/
U16 IRLightStr;    /**< Setting IR light source strength , range 0~100**/
}ISP_AE_RESULT;

/*! @brief AWB algorithm result*/
typedef struct
{
    U32 Size;       /**< struct size*/
    U32 Change;    /**< if true, apply this result to hw register*/
    U32 R_gain;     /**< AWB gain for R channel*/
    U32 G_gain;     /**< AWB gain for G channel*/
    U32 B_gain;     /**< AWB gain for B channel*/
    U32 ColorTmp;   /**< Return color temperature*/
}ISP_AWB_RESULT;

/*! @brief AF algorithm result*/
typedef struct
{
    u32 Size;           /**< struct size*/
    u32 Change; /**< if true, apply this result to hw*/
    u32 NextPos; /**< Next position*/
/**< CUS3A v1.3*/
    u32                   ChangeParam;      /** if true, apply the following 4 results to hw register **/
    CusAFRoiMode_t        ROIMode;          /** roi mode configuration**/
    CusAFWin_t            Window[16];       /** AF statistics window position **/
    CusAFFilter_t         Filter;           /** AF filter paramater**/
    CusAFFilterSq_t       FilterSq;         /** AF filter square parameter**/
} ISP_AF_RESULT;

/*ISP0 AE -> SStarAE*/
CUS3A_SetAlgoAdaptor(eIspCh0, eAdapNative, eAlgoAE) 
/*ISP0 AWB -> Customer AWB*/
CUS3A_SetAlgoAdaptor(eIspCh0, eAdap1, eAlgoAWB)
/*ISP0 AF -> Customer AF */
CUS3A_SetAlgoAdaptor(eIspCh0, eAdap1, eAlgoAF)

int CUS3A_RegInterface(U32 nCh, ISP_AE_INTERFACE *pAe, ISP_AWB_INTERFACE *pAwb, ISP_AF_INTERFACE *pAf)

int CUS3A_AERegInterface(u32 nCh,ISP_AE_INTERFACE *pAE);
int CUS3A_AWBRegInterface(u32 nCh,ISP_AWB_INTERFACE *pAWB);
int CUS3A_AFRegInterface(u32 nCh,ISP_AF_INTERFACE *pAF);

/**@brief ISP AE interface*/
typedef struct
{
    void *pdata; /**< Private data for AE algorithm.*/
    int (*init)(void* pdata, ISP_AE_INIT_PARAM *init_state);
    void (*release)(void* pdata);
    void (*run)(void* pdata, const ISP_AE_INFO *info, ISP_AE_RESULT *result);
    int (*ctrl)(void* pdata, ISP_AE_CTRL_CMD cmd, void* param);
} ISP_AE_INTERFACE;

typedef struct
{
    U32 Size;                   /**< struct size*/
    char sensor_id[32];             /**< sensor module id*/
    U32 shutter;                /**< shutter Shutter in us*/
    U32 shutter_step;           /**< shutter Shutter step ns*/
    U32 shutter_min;            /**< shutter Shutter min us*/
    U32 shutter_max;            /**< shutter Shutter max us*/
    U32 sensor_gain;            /**< sensor_gain Sensor gain, 1X = 1024*/
    U32 sensor_gain_min;        /**< sensor_gain_min Minimum Sensor gain, 1X = 1024*/
    U32 sensor_gain_max;        /**< sensor_gain_max Maximum Sensor gain, 1X = 1024*/
    U32 isp_gain;               /**< isp_gain Isp digital gain , 1X = 1024 */
    U32 isp_gain_max;           /**< isp_gain Maximum Isp digital gain , 1X = 1024 */
    U32 FNx10;                  /**< F number * 10*/
    U32 fps;                    /**< initial frame per second*/
    U32 shutterHDRShort_step;           /**< shutter Shutter step ns*/
    U32 shutterHDRShort_min;            /**< shutter Shutter min us*/
    U32 shutterHDRShort_max;            /**< shutter Shutter max us*/
    U32 sensor_gainHDRShort_min;        /**< sensor_gain_min Minimum Sensor gain, 1X = 1024*/
    U32 sensor_gainHDRShort_max;        /**< sensor_gain_max Maximum Sensor gain, 1X = 1024*/

    /*CUS3A v1.1*/
    U32 AvgBlkX;                  /**< HW statistics average block number*/
    U32 AvgBlkY;                  /**< HW statistics average block number*/
}ISP_AE_INIT_PARAM;

/*! @brief ISP report to AE, hardware statistic */
typedef struct
{
    U32 Size;       /**< struct size*/
    ISP_HIST  *hist1;   /**< HW statistic histogram 1*/
    ISP_HIST  *hist2;   /**< HW statistic histogram 2*/
    U32 AvgBlkX;  /**< HW statistics average block number*/
    U32 AvgBlkY;  /**< HW statistics average block number*/
    ISP_AE_SAMPLE *avgs; /**< HW statistics average block data*/
    U32 Shutter;                    /**< Current shutter in us*/
    U32 SensorGain;                 /**< Current Sensor gain, 1X = 1024 */
    U32 IspGain;                    /**< Current ISP gain, 1X = 1024*/
    U32 ShutterHDRShort;           /**< Current shutter in us*/
    U32 SensorGainHDRShort;        /**< Current Sensor gain, 1X = 1024 */
    U32 IspGainHDRShort;           /**< Current ISP gain, 1X = 1024*/

    /*CUS3A v1.1*/
    U32 PreAvgY;           /**< Previous frame brightness */
    U32 HDRCtlMode;        /**< 0 = HDR off;*/
                            /**< 1 = Separate shutter & Separate sensor gain settings*/
                            /**< 2 = Separate shutter & Share sensor gain settings*/
                            /**< 3 = Share shutter & Separate sensor gain settings*/
    U32 FNx10;             /**< Aperture in FNx10 */
    U32 CurFPS;            /**< Current sensor FPS */
    U32 PreWeightY;        /**< Previous frame brightness with ROI weight */

    /*CUS3A v1.2*/
    ISP_IR_HISTX *histIR;           /**< HW statistic histogram IR*/
/*CUS3A v1.3*/
U16 IRLightStr;    /**< Setting IR light source strength , range 0~100**/
} ISP_AE_INFO;

/*! @brief ISP ae algorithm result*/
typedef struct
{
    U32 Size;           /**< struct size*/
    U32 Change;       /**< if true, apply this result to hw register*/
    U32 Shutter;         /**< Shutter in us */
    U32 SensorGain;      /**< Sensor gain, 1X = 1024 */
    U32 IspGain;         /**< ISP gain, 1X = 1024 */
    U32 ShutterHdrShort;     /**< Shutter in us */
    U32 SensorGainHdrShort;  /**< Sensor gain, 1X = 1024 */
    U32 IspGainHdrShort;     /**< ISP gain, 1X = 1024 */
    U32 u4BVx16384;      /**< Bv * 16384 in APEX system, EV = Av + Tv = Sv + Bv */
    U32 AvgY;       /**< frame brightness */
    U32 HdrRatio;   /**< hdr ratio, 1X = 1024 */

    /*CUS3A v1.1*/
    U32 FNx10;           /**< F number * 10 */
    U32 DebandFPS;      /**< Target fps when running auto debanding*/
U32 WeightY;        /**< frame brightness with ROI weight*/

/*CUS3A v1.3*/
    U16 GMBlendRatio;   /**< Adaptive Gamma Blending Ratio from AE**/
U16 IRLightStr;    /**< Setting IR light source strength , range 0~100**/
}ISP_AE_RESULT;

int (*ctrl)(void* pdata,ISP_AE_CTRL_CMD cmd,void* param)

typedef enum
{
    ISP_AE_FPS_SET, /**< ISP notify AE sensor FPS has changed*/
}ISP_AE_CTRL_CMD;

typedef struct
{
    void *pdata; /**< Private data for AE algorithm.*/
    int (*init)(void *pdata);
    void (*release)(void *pdata);
    void (*run)(void *pdata, const ISP_AWB_INFO *awb_info, const ISP_AE_INFO *ae_info, ISP_AWB_RESULT *result);
    int (*ctrl)(void *pdata, ISP_AWB_CTRL_CMD cmd, void* param);
} ISP_AWB_INTERFACE

/*! @brief AWB HW statistics data*/
typedef struct
{
    U32 AvgBlkX;
    U32 AvgBlkY;
    U32 CurRGain;
    U32 CurGGain;
    U32 CurBGain;
    void *avgs;

    /*CUS3A v1.1*/
    U8 HDRMode;       /**< Noramal or HDR mode */
    void* pAwbStatisShort;      /**< Short Shutter AWB statistic data*/
    U32 u4BVx16384;    /**< From AE output, Bv * 16384 in APEX system, EV = Av + Tv = Sv + Bv  */
    S32 WeightY;       /**< frame brightness with ROI weight0 */
}__attribute__((packed, aligned(1))) ISP_AWB_INFO;

/*! @brief AWB algorithm result*/
typedef struct
{
U32 Size;       /**< struct size*/
U32 Change;    /**< if true, apply this result to hw register*/
    U32 R_gain;     /**< AWB gain for R channel*/
    U32 G_gain;     /**< AWB gain for G channel*/
    U32 B_gain;     /**< AWB gain for B channel*/
    U32 ColorTmp;   /**< Return color temperature*/
} ISP_AWB_RESULT;

int (*ctrl)(void* pdata,ISP_AWB_CTRL_CMD cmd,void* param)

typedef enum
{
    ISP_AWB_MODE_SET,
}ISP_AWB_CTRL_CMD;

typedef struct isp_af_interface
{
    void *pdata; /**< Private data for AF algorithm.*/
    int (*init)(void *pdata, ISP_AF_INIT_PARAM *param);   
void (*release)(void *pdata);
    void (*run)(void *pdata,const ISP_AF_INFO *af_info, ISP_AF_RESULT *result);
    int (*ctrl)(void *pdata,ISP_AF_CTRL_CMD cmd,void* param);
}ISP_AF_INTERFACE;

typedef struct _isp_af_init_param
{
    u32 Size; /**< struct size*/
    ISP_AF_RECT af_stats_win[16];
/**< CUS3A v1.3*/
    u32 CurPos; //motor current position
    u32 MinPos; //motor down position limit
    u32 MaxPos; //motor up position limit
    u32 MinStep;//motor minimum step
    u32 MaxStep;//motor maximum step
} ISP_AF_INIT_PARAM;

/*! @brief AF HW statistics data*/
typedef struct
{
    U32 Size;       /**< struct size*/
    ISP_AF_STATS pStats; /**< AF statistic*/
    u32 CurPos;     /**<motor current position*/
    u32 MinPos;     /**<motor down position limit*/
u32 MaxPos;     /**<motor up position limit*/
}ISP_AF_INFO;

//for Pretzel, Macaron, Pudding              //for Twinkie
typedef struct{                         typedef struct{
    MI_U8 high_iir[5*16];                       MI_U8 high_iir[6*16];
    MI_U8 low_iir[5*16];                        MI_U8 low_iir[6*16];
    MI_U8 luma[4*16];                           MI_U8 luma[6*16];
    MI_U8 sobel_v[5*16];                        MI_U8 sobel_v[6*16];
    MI_U8 sobel_h[5*16];                        MI_U8 sobel_h[6*16];
    MI_U8 ysat[3*16];                           MI_U8 ysat[3*16];
} AF_STATS_PARAM_t ;                        } AF_STATS_PARAM_t ;

typedef struct{                         typedef struct{
    AF_STATS_PARAM_t stParaAPI[16];             AF_STATS_PARAM_t stParaAPI;
} CusAFStats_t;                         } CusAFStats_t;

/*! @brief AF algorithm result*/
typedef struct
{
    u32 Size;           /**< struct size*/
    u32 Change; /**< if true, apply this result to hw*/
    u32 NextPos; /**< Next position*/
/**< CUS3A v1.3*/
    u32                   ChangeParam;      /** if true, apply the following 4 results to hw register **/
    CusAFRoiMode_t        ROIMode;          /** roi mode configuration**/
    CusAFWin_t            Window[16];       /** AF statistics window position **/
    CusAFFilter_t         Filter;           /** AF filter paramater**/
    CusAFFilterSq_t       FilterSq;         /** AF filter square parameter**/
} ISP_AF_RESULT;

#include <mi_isp.h>

//// AE INTERFACE TEST ////

int ae_init(void* pdata, ISP_AE_INIT_PARAM *init_state)
{
    printf("****** ae_init ,shutter=%d,shutter_step=%d,sensor_gain_min=%d,sensor_gain_max=%d *******\n",
        (int)init_state->shutter,
        (int)init_state->shutter_step,
        (int)init_state->sensor_gain,
        (int)init_state->sensor_gain_max
        );
    return 0;
}

void ae_run(void* pdata, const ISP_AE_INFO *info, ISP_AE_RESULT *result)
{
#define log_info 1

    // Only one can be chosen (the following three define)
#define shutter_test 0
#define gain_test 0
#define AE_sample 1

#if (shutter_test) || (gain_test)
    static int AE_period = 4;
#endif
    static unsigned int fcount = 0;
    unsigned int max = info->AvgBlkY * info->AvgBlkX;
    unsigned int avg = 0;
    unsigned int n;
#if gain_test
    static int tmp = 0;
    static int tmp1 = 0;
#endif

    result->Change              = 0;
    result->u4BVx16384          = 16384;
    result->HdrRatio            = 10; //infinity5 //TBD //10 * 1024;   //user define hdr exposure ratio
    result->IspGain             = 1024;
    result->SensorGain          = 4096;
    result->Shutter             = 20000;
    result->IspGainHdrShort     = 1024;
    result->SensorGainHdrShort  = 1024;
    result->ShutterHdrShort     = 1000;
    //result->Size         = sizeof(CusAEResult_t);

    for(n = 0; n < max; ++n)
    {
        avg += info->avgs[n].y;
    }
    avg /= max;

    result->AvgY         = avg;

#if shutter_test // shutter test under constant sensor gain
    int Shutter_Step = 100; //per frame
    int Shutter_Max = 33333;
    int Shutter_Min = 150;
    int Gain_Constant = 10240;

    result->SensorGain = Gain_Constant;
    result->Shutter = info->Shutter;

    if(++fcount % AE_period == 0)
    {
        if (tmp == 0)
        {
            result->Shutter = info->Shutter + Shutter_Step * AE_period;
            //printf("[shutter-up] result->Shutter = %d \n", result->SensorGain);
        }
        else
        {
            result->Shutter = info->Shutter - Shutter_Step * AE_period;
            //printf("[shutter-down] result->Shutter = %d \n", result->SensorGain);
        }
        if (result->Shutter >= Shutter_Max)
        {
            result->Shutter = Shutter_Max;
            tmp = 1;
        }
        if (result->Shutter <= Shutter_Min)
        {
            result->Shutter = Shutter_Min;
            tmp = 0;
        }
    }
#if log_info
    printf("fcount = %d, Image avg = 0x%X \n", fcount, avg);
    printf("tmp = %d, Shutter: %d -> %d \n", tmp, info->Shutter, result->Shutter);
#endif
#endif

#if gain_test // gain test under constant shutter
    int Gain_Step = 1024; //per frame
    int Gain_Max = 1024 * 100;
    int Gain_Min = 1024 * 2;
    int Shutter_Constant = 20000;

    result->SensorGain = info->SensorGain;
    result->Shutter = Shutter_Constant;

    if(++fcount % AE_period == 0)
    {
        if (tmp1 == 0)
        {
            result->SensorGain = info->SensorGain + Gain_Step * AE_period;
            //printf("[gain-up] result->SensorGain = %d \n", result->SensorGain);
        }
        else
        {
            result->SensorGain = info->SensorGain - Gain_Step * AE_period;
            //printf("[gain-down] result->SensorGain = %d \n", result->SensorGain);
        }
        if (result->SensorGain >= Gain_Max)
        {
            result->SensorGain = Gain_Max;
            tmp1 = 1;
        }
        if (result->SensorGain <= Gain_Min)
        {
            result->SensorGain = Gain_Min;
            tmp1 = 0;
        }
    }
#if log_info
    printf("fcount = %d, Image avg = 0x%X \n", fcount, avg);
    printf("tmp = %d, SensorGain: %d -> %d \n", tmp, info->SensorGain, result->SensorGain);
#endif
#endif

#if AE_sample
    int y_lower = 0x28;
    int y_upper = 0x38;
    int change_ratio = 10; // percentage
    int Gain_Min = 1024 * 2;
    int Gain_Max = 1024 * 1000;
    int Shutter_Min = 150;
    int Shutter_Max = 33333;

    result->SensorGain = info->SensorGain;
    result->Shutter = info->Shutter;

    if(avg < y_lower)
    {
        if (info->Shutter < Shutter_Max)
        {
            result->Shutter = info->Shutter + (info->Shutter * change_ratio / 100);
            if (result->Shutter > Shutter_Max) result->Shutter = Shutter_Max;
        }
        else
        {
            result->SensorGain = info->SensorGain + (info->SensorGain * change_ratio / 100);
            if (result->SensorGain > Gain_Max) result->SensorGain = Gain_Max;
        }
        result->Change = 1;
    }
    else if(avg > y_upper)
    {
        if (info->SensorGain > Gain_Min)
        {
            result->SensorGain = info->SensorGain - (info->SensorGain * change_ratio / 100);
            if (result->SensorGain < Gain_Min) result->SensorGain = Gain_Min;
        }
        else
        {
            result->Shutter = info->Shutter - (info->Shutter * change_ratio / 100);
            if (result->Shutter < Shutter_Min) result->Shutter = Shutter_Min;
        }
        result->Change = 1;
    }

#if 0 //infinity5 //TBD
    //hdr demo code
    result->SensorGainHdrShort = result->SensorGain;
    result->ShutterHdrShort = result->Shutter * 1024 / result->HdrRatio;
#endif

#if log_info
    printf("fcount = %d, Image avg = 0x%X \n", fcount, avg);
    printf("SensorGain: %d -> %d \n", (int)info->SensorGain, (int)result->SensorGain);
    printf("Shutter: %d -> %d \n", (int)info->Shutter, (int)result->Shutter);
#endif

#endif
}

void ae_release(void* pdata)
{
    printf("************* ae_release *************\n");
}

//// AWB INTERFACE TEST ////

int awb_init(void *pdata)
{
    printf("************ awb_init **********\n");
    return 0;
}
 
void awb_run(void* pdata, const ISP_AWB_INFO *info, ISP_AWB_RESULT *result)
{
#define log_info 1

    static u32 count = 0;
    int avg_r = 0;
    int avg_g = 0;
    int avg_b = 0;
    int tar_rgain = 1024;
    int tar_bgain = 1024;
    int x = 0;
    int y = 0;

    result->R_gain = info->CurRGain;
    result->G_gain = info->CurGGain;
    result->B_gain = info->CurBGain;
    result->Change = 0;
    result->ColorTmp = 6000;

    if (++count % 4 == 0)
    {
        //center area YR/G/B avg
        for (y = 30; y < 60; ++y)
        {
            for (x = 32; x < 96; ++x)
            {
                avg_r += info->avgs[info->AvgBlkX * y + x].r;
                avg_g += info->avgs[info->AvgBlkX * y + x].g;
                avg_b += info->avgs[info->AvgBlkX * y + x].b;
            }
        }
        avg_r /= 30 * 64;
        avg_g /= 30 * 64;
        avg_b /= 30 * 64;

        if (avg_r < 1)
            avg_r = 1;
        if (avg_g < 1)
            avg_g = 1;
        if (avg_b < 1)
            avg_b = 1;

#if log_info
        printf("AVG R / G / B = %d, %d, %d \n", avg_r, avg_g, avg_b);
#endif

        // calculate Rgain, Bgain
        tar_rgain = avg_g * 1024 / avg_r;
        tar_bgain = avg_g * 1024 / avg_b;

        if (tar_rgain > info->CurRGain)
        {
            if (tar_rgain - info->CurRGain < 384)
                result->R_gain = tar_rgain;
            else
                result->R_gain = info->CurRGain + (tar_rgain - info->CurRGain) / 10;
        }
        else
        {
            if (info->CurRGain - tar_rgain < 384)
                result->R_gain = tar_rgain;
            else
                result->R_gain = info->CurRGain - (info->CurRGain - tar_rgain) / 10;
        }

        if (tar_bgain > info->CurBGain)
        {
            if (tar_bgain - info->CurBGain < 384)
                result->B_gain = tar_bgain;
            else
                result->B_gain = info->CurBGain + (tar_bgain - info->CurBGain) / 10;
        }
        else
        {
            if (info->CurBGain - tar_bgain < 384)
                result->B_gain = tar_bgain;
            else
                result->B_gain = info->CurBGain - (info->CurBGain - tar_bgain) / 10;
        }

        result->Change = 1;
        result->G_gain = 1024;

#if log_info
        printf("[current] r=%d, g=%d, b=%d \n", (int)info->CurRGain, (int)info->CurGGain, (int)info->CurBGain);
        printf("[result] r=%d, g=%d, b=%d \n", (int)result->R_gain, (int)result->G_gain, (int)result->B_gain);
#endif
    }
}

void awb_release(void *pdata)
{
    printf("************ awb_release **********\n");
}

//// AF INTERFACE TEST ////

int af_init(void *pdata, ISP_AF_INIT_PARAM *param)
{
    MI_U32 u32ch = 0;
    MI_U8 u8win_idx = 16;
    CusAFRoiMode_t taf_roimode;
    CusAFWin_t taf_win;

    printf("************ af_init **********\n");
#if 0
    //Init Normal mode setting
    taf_roimode.mode = AF_ROI_MODE_NORMAL;
    taf_roimode.u32_vertical_block_number = 1;
    MI_ISP_CUS3A_SetAFRoiMode(u32ch, &taf_roimode);

    static CusAFWin_t afwin[16] =
    {
        { 0, {   0,    0,  255,  255}},
        { 1, { 256,    0,  511,  255}},
        { 2, { 512,    0,  767,  255}},
        { 3, { 768,    0, 1023,  255}},
        { 4, {   0,  256,  255,  511}},
        { 5, { 256,  256,  511,  511}},
        { 6, { 512,  256,  767,  511}},
        { 7, { 768,  256, 1023,  511}},
        { 8, {   0,  512,  255,  767}},
        { 9, { 256,  512,  511,  767}},
        {10, { 512,  512,  767,  767}},
        {11, { 768,  512, 1023,  767}},
        {12, {   0,  768,  255, 1023}},
        {13, { 256,  768,  511, 1023}},
        {14, { 512,  768,  767, 1023}},
        {15, { 768,  768, 1023, 1023}}
    };
    for(u8win_idx = 0; u8win_idx < 16; ++u8win_idx){
        MI_ISP_CUS3A_SetAFWindow(u32ch, &afwin[u8win_idx]);
    }

#else
    //Init Matrix mode setting
    taf_roimode.mode = AF_ROI_MODE_MATRIX;
    taf_roimode.u32_vertical_block_number = 16; //16xN, N=16
    MI_ISP_CUS3A_SetAFRoiMode(u32ch, &taf_roimode);

    static CusAFWin_t afwin[16] =
    {
        #if 1
        //full image, equal divide to 16x16
        {0, {0, 0, 63, 63}},
        {1, {64, 64, 127, 127}},
        {2, {128, 128, 191, 191}},
        {3, {192, 192, 255, 255}},
        {4, {256, 256, 319, 319}},
        {5, {320, 320, 383, 383}},
        {6, {384, 384, 447, 447}},
        {7, {448, 448, 511, 511}},
        {8, {512, 512, 575, 575}},
        {9, {576, 576, 639, 639}},
        {10, {640, 640, 703, 703}},
        {11, {704, 704, 767, 767}},
        {12, {768, 768, 831, 831}},
        {13, {832, 832, 895, 895}},
        {14, {896, 896, 959, 959}},
        {15, {960, 960, 1023, 1023}}
        #else
        //use two row only => 16x2 win
        {0, {0, 0, 63, 63}},
        {1, {64, 64, 127, 127}},
        {2, {128, 0, 191, 2}},      //win2 v_str, v_end doesn't use, set to (0, 2)
        {3, {192, 0, 255, 2}},
        {4, {256, 0, 319, 2}},
        {5, {320, 0, 383, 2}},
        {6, {384, 0, 447, 2}},
        {7, {448, 0, 511, 2}},
        {8, {512, 0, 575, 2}},
        {9, {576, 0, 639, 2}},
        {10, {640, 0, 703, 2}},
        {11, {704, 0, 767, 2}},
        {12, {768, 0, 831, 2}},
        {13, {832, 0, 895, 2}},
        {14, {896, 0, 959, 2}},
        {15, {960, 0, 1023, 2}}
        #endif
    };

    for(u8win_idx = 0; u8win_idx < 16; ++u8win_idx){
        MI_ISP_CUS3A_SetAFWindow(u32ch, &afwin[u8win_idx]);
    }
#endif

    static CusAFFilter_t affilter =
    {
#if Twinkie || Pretzel || Macaron
        //filter setting with sign value
        //{63, -126, 63, -109, 48, 0, 320, 0, 1023},
        //{63, -126, 63, 65, 55, 0, 320, 0, 1023}

        //convert to hw format (sign bit with msb)
        63, 126+1024, 63, 109+128, 48, 0, 320, 0, 1023,
        63, 126+1024, 63, 65, 55, 0, 320, 0, 1023,
#elseif Pudding
        //filter setting with sign value
        //{s9, s10, s9, s7, s7}
        //high: 37, 0, -37, 83, 40; 37, 0, -37, -54, 34; 32, 0, -32, 14, 0
        //low:  15, 0, -15, -79, 44; 15, 0, -15, -115, 55; 14, 0, -14, -91, 37

        //convert to hw format (sign bit with msb)
        37, 0, 37+512, 83, 40, 0, 1023, 0, 1023,    //high
        15, 0, 15+512, 79+128, 44, 0, 1023, 0, 1023,    //low
        1, 37, 0, 37+512,  54+128, 34, 1, 32, 0, 32+512, 14, 0, //high-e1, e2
        1, 15, 0, 15+512, 115+128, 55, 1, 14, 0, 14+512, 91+128, 37,  //low-e1, e2
#endif
    };

    MI_ISP_CUS3A_SetAFFilter(0, &affilter);
    return 0;
}

void af_run(void *pdata, const ISP_AF_INFO *af_info, ISP_AF_RESULT *result)
{
    #define af_log_info 1

#if af_log_info
    int i=0,x=0;

    printf("\n\n");

    //print row0 16wins
    x=0;
    for (i=0; i<16; i++){
        printf("[AF]win%d-%d iir0: 0x%02x%02x%02x%02x%02x, iir1:0x%02x%02x%02x%02x%02x, luma:0x%02x%02x%02x%02x, sobelh:0x%02x%02x%02x%02x%02x, sobelv:0x%02x%02x%02x%02x%02x ysat:0x%02x%02x%02x\n",
            x, i,
            af_info->af_stats.stParaAPI[x].high_iir[4+i*5],af_info->af_stats.stParaAPI[x].high_iir[3+i*5],af_info->af_stats.stParaAPI[x].high_iir[2+i*5],af_info->af_stats.stParaAPI[x].high_iir[1+i*5],af_info->af_stats.stParaAPI[x].high_iir[0+i*5],
            af_info->af_stats.stParaAPI[x].low_iir[4+i*5],af_info->af_stats.stParaAPI[x].low_iir[3+i*5],af_info->af_stats.stParaAPI[x].low_iir[2+i*5],af_info->af_stats.stParaAPI[x].low_iir[1+i*5],af_info->af_stats.stParaAPI[x].low_iir[0+i*5],
            af_info->af_stats.stParaAPI[x].luma[3+i*4],af_info->af_stats.stParaAPI[x].luma[2+i*4],af_info->af_stats.stParaAPI[x].luma[1+i*4],af_info->af_stats.stParaAPI[x].luma[0+i*4],
            af_info->af_stats.stParaAPI[x].sobel_h[4+i*5],af_info->af_stats.stParaAPI[x].sobel_h[3+i*5],af_info->af_stats.stParaAPI[x].sobel_h[2+i*5],af_info->af_stats.stParaAPI[x].sobel_h[1+i*5],af_info->af_stats.stParaAPI[x].sobel_h[0+i*5],
            af_info->af_stats.stParaAPI[x].sobel_v[4+i*5],af_info->af_stats.stParaAPI[x].sobel_v[3+i*5],af_info->af_stats.stParaAPI[x].sobel_v[2+i*5],af_info->af_stats.stParaAPI[x].sobel_v[1+i*5],af_info->af_stats.stParaAPI[x].sobel_v[0+i*5],
            af_info->af_stats.stParaAPI[x].ysat[2+i*3],af_info->af_stats.stParaAPI[x].ysat[1+i*3],af_info->af_stats.stParaAPI[x].ysat[0+i*3]
            );
    }

    //print row15 16wins
    x=15;
    for (i=0; i<16; i++){
        printf("[AF]win%d-%d iir0: 0x%02x%02x%02x%02x%02x, iir1:0x%02x%02x%02x%02x%02x, luma:0x%02x%02x%02x%02x, sobelh:0x%02x%02x%02x%02x%02x, sobelv:0x%02x%02x%02x%02x%02x ysat:0x%02x%02x%02x\n",
            x, i,
            af_info->af_stats.stParaAPI[x].high_iir[4+i*5],af_info->af_stats.stParaAPI[x].high_iir[3+i*5],af_info->af_stats.stParaAPI[x].high_iir[2+i*5],af_info->af_stats.stParaAPI[x].high_iir[1+i*5],af_info->af_stats.stParaAPI[x].high_iir[0+i*5],
            af_info->af_stats.stParaAPI[x].low_iir[4+i*5],af_info->af_stats.stParaAPI[x].low_iir[3+i*5],af_info->af_stats.stParaAPI[x].low_iir[2+i*5],af_info->af_stats.stParaAPI[x].low_iir[1+i*5],af_info->af_stats.stParaAPI[x].low_iir[0+i*5],
            af_info->af_stats.stParaAPI[x].luma[3+i*4],af_info->af_stats.stParaAPI[x].luma[2+i*4],af_info->af_stats.stParaAPI[x].luma[1+i*4],af_info->af_stats.stParaAPI[x].luma[0+i*4],
            af_info->af_stats.stParaAPI[x].sobel_h[4+i*5],af_info->af_stats.stParaAPI[x].sobel_h[3+i*5],af_info->af_stats.stParaAPI[x].sobel_h[2+i*5],af_info->af_stats.stParaAPI[x].sobel_h[1+i*5],af_info->af_stats.stParaAPI[x].sobel_h[0+i*5],
            af_info->af_stats.stParaAPI[x].sobel_v[4+i*5],af_info->af_stats.stParaAPI[x].sobel_v[3+i*5],af_info->af_stats.stParaAPI[x].sobel_v[2+i*5],af_info->af_stats.stParaAPI[x].sobel_v[1+i*5],af_info->af_stats.stParaAPI[x].sobel_v[0+i*5],
            af_info->af_stats.stParaAPI[x].ysat[2+i*3],af_info->af_stats.stParaAPI[x].ysat[1+i*3],af_info->af_stats.stParaAPI[x].ysat[0+i*3]
            );
    }
#endif}

void af_release(void *pdata)
{
    printf("************ af_release **********\n");
}

int main(int argc,char** argv)
{
    //TO DO: Register 3rd party AE/AWB library
    ISP_AE_INTERFACE tAeIf;
    ISP_AWB_INTERFACE tAwbIf;

    CUS3A_Init();

    /*AE*/
    tAeIf.ctrl = NULL;
    tAeIf.pdata = NULL;
    tAeIf.init = ae_init;
    tAeIf.release = ae_release;
    tAeIf.run = ae_run;

    /*AWB*/
    tAwbIf.ctrl = NULL;
    tAwbIf.pdata = NULL;
    tAwbIf.init = awb_init;
    tAwbIf.release = awb_release;
    tAwbIf.run = awb_run;

CUS3A_RegInterface(0,&tAeIf,&tAwbIf,NULL);
// or use below reginterface
//CUS3A_AERegInterface(0,&tAeIf);
//CUS3A_AWBRegInterface(0,&tAwbIf);

//TO DO: Open MI
MI_SYS_Init();
while(1)
{
usleep(5000);
}
}